# encoding: UTF-8

#GRUPO FORMADO POR: Antonio Espinosa Jiménez, Silvia Mikue Yembi Abaga,
#Mario Andrés Pérez Batanero

require_relative 'napakalaki'
require_relative 'prize'
require_relative 'monster'


#El esquema del juego es el siguiente:

#(0) initGame() rellena el ArrayList de jugadores, inicializa las cartas,  
#        En el primer turno de cada jugador, tira un dado:
#        si sale 1, empieza con un tesoro oculto
#        si sale de 2 a 5, empieza con 2 tesoros ocultos
#        si sale un 6, empieza con 3 tesoros ocultos
#        
#        + Se repite hasta el que jugador alcanza el nivel 10:
#        
#            (1) Comprar niveles con las cartas ocultas o visibles actuales (debe poder elegir).
#
#            (2) Sacar un monstruo de la baraja de unusedMonster.
#
#            (3) Combatir con el monstruo (una vez terminado el combate se mete en la baraja usedMonster).
#
#            (4) Al final del turno el jugador puede equiparse con nuevos tesoros ocultos (debe poder elegir).
#
module Napakalaki
  class PruebaJuego
    def initialize      
    end        
    
    
    #METODO (FUNCION) para mostrar el estado del jugador actual
    def self.puts_estado_actual(juego)
      puts "\t\t\t\t*** NIVEL: #{juego.current_player.level} ***"
      puts "\nTUS CARTAS VISIBLES SON: "
      juego.current_player.visible_treasures.each do |i|
        puts i
      end
      
      print "\nTUS CARTAS OCULTAS SON: "
      juego.current_player.hidden_treasures.each do |i|
        puts i
      end
      puts "###################################################################################"
    end
    
    
    #creo la colección con el nombre de los jugadores   ###########################################
    nombres_jugadores = Array.new
    puts "\t¡¡¡ BIENVENIDO A NAPAKALAKI !!!"    
    puts "Dime el número de jugadores (entre 1 y 3): "  
    leido = gets.chomp.to_i

    #añado el nombre del jugador a la colección
    (1..leido).each do |i|
      puts "\tDime el nombre del jugador #{i}: "
      nombres_jugadores << gets.chomp
    end    
    
    #Inicio el juego pasandole los nombres
    juego=Napakalaki.instance    
    juego.init_game(nombres_jugadores)
    resultado_combate = nil

    #BUCLE principal que se repite en cada turno
    begin      
      
      puts "\n\n====================================================================================="
      puts "=================================== TURNO DE #{juego.current_player.name} ===================================="
      puts "====================================================================================="
      
      #le decimos al jugados las cartas que tiene y le preguntamos si quiere comprar,
      #si quiere nos tiene que indicar cuales va a vender
      puts_estado_actual(juego)
      
      #INICIO COMPRAR NIVELES
      #si no tiene cartas, no puede comprar nada, salta el proceso de compra
      if(!juego.current_player.hidden_treasures.empty? || !juego.current_player.visible_treasures.empty?)
        begin
          comprar = "";
          puts "\n¿Quieres comprar niveles con tus cartas actuales? (s/n): "
          comprar = gets.chomp

          if comprar == 's'
            numero_cartas_a_borrar = 0
            indice_carta = 0
            cartas_a_borrar_ocultas = Array.new
            cartas_a_borrar_visibles = Array.new

            begin #pregunto mientras no se meta un número válido
              puts "\t¿Cuántas cartas quieres vender? (Cada 1000 piezas de oro subes 1 nivel): "
              numero_cartas_a_borrar = gets.chomp.to_i
            end while (numero_cartas_a_borrar > (juego.current_player.hidden_treasures.size + juego.current_player.visible_treasures.size))

            (1..numero_cartas_a_borrar).each do |i|            
              begin                
                puts "\t\tCarta #{i}.- ¿Es oculta o visible? (o/v): "
                leido = gets.chomp
                if (leido == 'o' && !juego.current_player.hidden_treasures.empty?)                    
                  begin
                    puts "\t\tCarta #{i}.- Dime el numero de orden que ocupa dentro de las ocultas: "
                    indice_carta = gets.chomp.to_i
                  end while (indice_carta <= 0 || (indice_carta > juego.current_player.hidden_treasures.size))                                  
                  cartas_a_borrar_ocultas << juego.current_player.hidden_treasures.at(indice_carta - 1)
                elsif (leido == 'v' && !juego.current_player.visible_treasures.empty?)                    
                  begin
                    puts "\t\tCarta #{i}.- Dime el numero de orden que ocupa dentro de las visibles: "
                    indice_carta = gets.chomp.to_i
                  end while (indice_carta <= 0 || (indice_carta > juego.current_player.visible_treasures.size))
                  cartas_a_borrar_visibles << juego.current_player.visible_treasures.at(indice_carta - 1)                 
                  # else
                  #NO CONCUERDA LA ELECCION                  
                  #leido = "z" # para que no salga                  
                end              
              end while ((leido != 'o') && (leido != 'v'))            
            end
            juego.buy_levels(cartas_a_borrar_visibles, cartas_a_borrar_ocultas)


            puts "\n########################## ESTADO DESPUÉS DE VENDER: ##############################"
            puts_estado_actual(juego)
            puts "####################################################################################"
          end
          
        end while (comprar != 's') && (comprar != 'n')                
      end 
      #FIN COMPRA NIVELES
      
      puts "\n\n***************************** Voy a luchar contra: ********************************* #{juego.current_monster}"
      puts "*************************************************************************************"
      #COMBATE
      resultado_combate = juego.develop_combat
      puts "====================================================================================="      

      
      case resultado_combate
      when :LOSEANDDIE
        puts "\t\t\tPIERDES EL COMBATE Y MUERES."
        #juego.current_player.init_treasures  <-- ESTO LO HACE nextTurn, si el jugador esta muerto llama a init_treasures
      when :WIN
        puts "\t\t\tGANAS EL COMBATE."
      when :LOSE
        puts "\t\t\tPIERDES EL COMBATE."
      when :LOSEANDSCAPE
        puts "\t\t\tPIERDES EL COMBATE PERO CONSIGUES ESCAPAR."
      when :LOSEANDCONVERT
        puts "\t\t\tPIERDES EL COMBATE Y TE CONVIERTES EN SECTARIO"
      end     
      
      #COMPROBAMOS SI GANA EL JUEGO
      if juego.end_of_game(resultado_combate)
        puts "\t\t\t¡¡¡#{juego.current_player.name} GANA EL JUEGO!!!"
        next #PASA A LA SIGUIENTE ITERACION DEL BUCLE PRINCIPAL, pasa al siguiente turno, y al comprobar end_of_game debe salirse
      end
      
      #POR AQUI SIGUE SINO SE HA ACABADO EL JUEGO
      if !juego.end_of_game(resultado_combate)  # si el juego no ha terminado
        #me descarto del badStuff antes de terminar el turno
        if !juego.current_player.pending_bad_stuff.specific_hidden_treasures.empty?  #si tengo ocultos pendientes

          juego.current_player.pending_bad_stuff.specific_hidden_treasures.each do |i| #para cada oculto pendiente

            juego.current_player.hidden_treasures.each do |j|  #para cada oculto que tiene currentPlayer

              if i == j.type
                juego.current_player.hidden_treasures.delete(j)
                juego.current_player.pending_bad_stuff.specific_hidden_treasures.delete(i)
              end
            end
          end
        end
        
        
        if !juego.current_player.pending_bad_stuff.specific_visible_treasures.empty?  #si tengo visibles pendientes

          juego.current_player.pending_bad_stuff.specific_visible_treasures.each do |i| #para cada visible pendiente

            juego.current_player.visible_treasures.each do |j|  #para cada visible que tiene currentPlayer
           
              if i == j.type
                juego.current_player.visible_treasures.delete(j)
                juego.current_player.pending_bad_stuff.specific_visible_treasures.delete(i)
              end
            end
          end
        end  
      
        
        puts "====================================================================================="


        puts "\n\n\n################################ TU ESTADO ACTUAL ES : ##############################"
        puts_estado_actual(juego)    
      
        if !juego.current_player.hidden_treasures.empty?
          numero_cartas_a_equipar = 0
          indice_carta = 0
          cartas_a_equipar = Array.new
          
          puts "¿Quieres equiparte algo? "
          leido = gets.chomp

          if leido == 's'
            begin
              puts "\t¿Cuántas cartas quieres equiparte? "
              numero_cartas_a_equipar = gets.chomp.to_i
            end while (numero_cartas_a_equipar <=0 || numero_cartas_a_equipar > (juego.current_player.hidden_treasures.size + juego.current_player.visible_treasures.size))
          
            (1..numero_cartas_a_equipar).each do |i|
              begin
                puts "\t\t--> #{i}ª Carta.- Dime el numero de orden que ocupa dentro de las ocultas: "
                indice_carta = gets.chomp.to_i
              end while indice_carta <= 0 || (indice_carta > juego.current_player.hidden_treasures.size)
              cartas_a_equipar << juego.current_player.hidden_treasures.at(indice_carta - 1)
            end
          end
          #EQUIPAMOS
          juego.make_treasures_visible(cartas_a_equipar);
        end
      
        #PASAMOS AL SIGUIENTE TURNO
        begin
          #SI FALLA nextTurn, debe ser porque el jugador actual está en un estado INvalido, lo corregimos
          if !juego.next_turn
            puts "Actualmente tienes más de 4 cartas ocultas, tienes que descartarte para tener como mucho 4."
            puts "\nTUS CARTAS OCULTAS SON: #{juego.current_player.hidden_treasures}"
            numero_descartes = juego.current_player.hidden_treasures.size - 4
            cartas_a_descartar = Array.new
            puts "Tienes que descartarte #{numero_descartes} cartas"
            (1..numero_descartes).each do |i|
              begin
                puts "Dime el número de orden que ocupa el descarte #{i}: "
                indice_carta = gets.chomp.to_i
              end while indice_carta <= 0 || (indice_carta > juego.current_player.hidden_treasures.size)
              cartas_a_descartar << juego.current_player.hidden_treasures.at(indice_carta-1)
            end
            #Descarto las cartas
            juego.discard_hidden_treasures(cartas_a_descartar) 
          end        
        end while !juego.next_turn
      end
      #Condicion para acabar el juego
    end while !juego.end_of_game(resultado_combate)    

  end
end
